﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace LunarSF.SHomeWorkshop.LMParser.MarkdownDOM
{
    public abstract class 匹配规则
    {
        public enum 匹配规则类别
        {
            单行匹配规则,
            连续单行匹配规则,
            嵌套多行匹配规则,
        }

        public 匹配规则(元素名称 rule_name)
        {
            _规则元素名称 = rule_name;
        }

        private 元素名称 _规则元素名称;

        public 元素名称 规则元素名称
        {
            get { return _规则元素名称; }
        }
    }

    public abstract class 单行匹配规则 : 匹配规则
    {
        public 单行匹配规则(元素名称 rule_name, string rule_text) : base(rule_name)
        {
            _规则文本 = rule_text;
            if(string.IsNullOrEmpty(rule_text)== false)
            {
                _表达式 = new Regex(_规则文本, RegexOptions.IgnoreCase);
            }
        }

        protected string _规则文本 = null;

        public string 规则文本
        {
            get { return _规则文本; }
        }

        private Regex _表达式 = null; 

        public Regex 表达式
        {
            get { return _表达式; }
        }
    }

    public abstract class 连续多行匹配规则 : 匹配规则
    {
        public 连续多行匹配规则(元素名称 rule_name, string rule_text) : base(rule_name)
        {
            _规则文本 = rule_text;
            if (string.IsNullOrEmpty(rule_text) == false)
            {
                _表达式 = new Regex(_规则文本, RegexOptions.IgnoreCase);
            }
        }

        protected string _规则文本 = null;

        public string 规则文本
        {
            get { return _规则文本; }
        }

        private Regex _表达式 = null;

        public Regex 表达式
        {
            get { return _表达式; }
        }
    }

    public abstract class 嵌套多行匹配规则 : 匹配规则
    {
        public 嵌套多行匹配规则(元素名称 rule_name, string head_rule, string tail_rule) : base(rule_name)
        {
            this._头规则文本 = head_rule;
            this._尾规则文本 = tail_rule;

            if (string.IsNullOrEmpty(head_rule) == false)
            {
                _头表达式 = new Regex(_头规则文本, RegexOptions.IgnoreCase);
            }

            if (string.IsNullOrEmpty(tail_rule) == false)
            {
                _尾表达式 = new Regex(_尾规则文本, RegexOptions.IgnoreCase);
            }
        }

        protected string _头规则文本 = null;

        public string 头规则文本
        {
            get { return _头规则文本; }
        }

        private string _尾规则文本 = null;

        public string 尾规则文本
        {
            get { return _尾规则文本; }
        }

        private Regex _头表达式 = null;

        public Regex 头表达式
        {
            get { return _头表达式; }
        }

        private Regex _尾表达式 = null;

        public Regex 尾表达式
        {
            get { return _尾表达式; }
        }
    }

    /// <summary>
    /// 兜底规则.
    /// </summary>
    public class 普通文本匹配规则 : 单行匹配规则
    {
        public 普通文本匹配规则() : base(元素名称.普通文本, null)
        {
            // 这是用来兜底的,不能识别的都算普通文本.
        }
    }

    public class 分号注释匹配规则 : 单行匹配规则
    {
        public 分号注释匹配规则(string ruleText) : base(元素名称.分号注释行, ruleText)
        {
            this._规则文本 = ruleText;
        }
    }

    public class 冒号注释匹配规则 : 单行匹配规则
    {
        public 冒号注释匹配规则(string ruleText) : base(元素名称.冒号注释行, ruleText)
        {
            this._规则文本 = ruleText;
        }
    }

    public class 六级标题行匹配规则 : 单行匹配规则
    {
        public 六级标题行匹配规则(string ruleText) : base(元素名称.六级标题行, ruleText)
        {
            this._规则文本 = ruleText;
        }
    }
}
